home *** CD-ROM | disk | FTP | other *** search
/ 3D Games - Real-time Rend…ng & Software Technology / 3D Games - Real-time Rendering & Software Technology.iso / flysdk / lib / ImpExp3ds / 3dsExport.cpp next >
Encoding:
C/C++ Source or Header  |  2000-03-13  |  10.0 KB  |  422 lines
  1. #include "../Fly3D.h"
  2.  
  3. export3ds::export3ds(char *filename, float scale, material *matlib, int nmatlib)
  4. {
  5.     m_fp=fopen(filename,"wb");
  6.     if(m_fp==NULL)
  7.         return;
  8.  
  9.     M3DMAGIC_bpatch=WriteChunk(M3DMAGIC, 0);
  10.     M3DMAGIC_size=SizeofChunk;
  11.  
  12.     WriteChunk(M3D_VERSION, SizeofChunk+sizeof(long));
  13.     WriteLong(4);
  14.     M3DMAGIC_size+=SizeofChunk+sizeof(long);
  15.  
  16.     WriteChunk(MASTER_SCALE, SizeofChunk+sizeof(float));
  17.     WriteFloat(scale);
  18.     M3DMAGIC_size+=SizeofChunk+sizeof(float);
  19.  
  20.     WriteMData_Ini(matlib, nmatlib);
  21. }
  22.  
  23. export3ds::~export3ds()
  24. {
  25.     if(m_fp!=NULL)
  26.         close();
  27. }
  28.  
  29. void export3ds::close()
  30. {
  31.     if(m_fp==NULL)
  32.         return;
  33.     M3DMAGIC_size+=WriteMData_Fim();
  34.     WritePatch(M3DMAGIC_bpatch, M3DMAGIC_size);
  35.     fclose(m_fp);
  36.     m_fp=NULL;
  37. }
  38.  
  39. long export3ds::WriteChunk(unsigned short id, long size)
  40. {
  41.     long retval;
  42.  
  43.     WriteUShort(id);
  44.     retval=ftell(m_fp);
  45.     WriteULong((unsigned long) size);
  46.  
  47.     return retval;
  48. }
  49.  
  50. long export3ds::WritePatch(long location, long data)
  51. {
  52.     long current=ftell(m_fp);
  53.     fseek(m_fp, location, SEEK_SET);
  54.     WriteLong(data);
  55.     fseek(m_fp, current, SEEK_SET);
  56.  
  57.     return current;
  58. }
  59.  
  60. void export3ds::WriteMData_Ini(material *matlib, int nmatlib)
  61. {
  62.     MDATA_bpatch=WriteChunk(MDATA, 0);
  63.     MDATA_size=SizeofChunk;
  64.     MDATA_size+=WriteMeshVersion(2L);
  65.     MDATA_size+=WriteMatEntries(matlib, nmatlib);
  66. }
  67.  
  68. long export3ds::WriteMData_Fim()
  69. {
  70.     WritePatch(MDATA_bpatch, MDATA_size);
  71.  
  72.     return MDATA_size;
  73. }
  74.  
  75. long export3ds::WriteMeshVersion(long version)
  76. {
  77.     WriteChunk(MESH_VERSION, SizeofChunk+sizeof(long));
  78.     WriteLong(version);
  79.     
  80.     return SizeofChunk+sizeof(long);
  81. }
  82.  
  83. long export3ds::WriteChunkString(unsigned short id, char *buffer)
  84. {
  85.     long size;
  86.  
  87.     size=SizeofChunk+strlen(buffer)+1;
  88.     WriteChunk(id, size);
  89.     WriteString(buffer);
  90.  
  91.     return size;
  92. }
  93.  
  94. void export3ds::WriteString(char *buffer)
  95. {
  96.     unsigned int j;
  97.  
  98.     for(j=0;j<strlen(buffer);j++)
  99.         WriteByte(buffer[j]);
  100.  
  101.     WriteByte('\0');
  102. }
  103.  
  104. long export3ds::WriteChunkMapping(unsigned short id, struct mapping *m)
  105. {
  106.     if(m->filename[0]==0)
  107.         return 0;
  108.  
  109.     long size=0, bpatch;
  110.  
  111.     bpatch=WriteChunk(id , 0);
  112.     size=SizeofChunk;
  113.  
  114.     WriteChunk(INT_PERCENTAGE, SizeofChunk+sizeof(short));
  115.     WriteShort(m->amount);
  116.     size+=SizeofChunk+sizeof(short);
  117.  
  118.     size+=WriteChunkString(MAPP_FILENAME, m->filename);
  119.  
  120.     WriteChunk(MAPP_OPTIONS, SizeofChunk+sizeof(short));
  121.     WriteShort(m->options);
  122.     size+=SizeofChunk+sizeof(short);
  123.  
  124.     WriteChunk(MAPP_FILTERING, SizeofChunk+sizeof(float));
  125.     WriteFloat(m->filtering);
  126.     size+=SizeofChunk+sizeof(float);
  127.  
  128.     WriteChunk(MAPP_U_SCALE, SizeofChunk+sizeof(float));
  129.     WriteFloat(m->u_scale);
  130.     size+=SizeofChunk+sizeof(float);
  131.  
  132.     WriteChunk(MAPP_V_SCALE, SizeofChunk+sizeof(float));
  133.     WriteFloat(m->v_scale);
  134.     size+=SizeofChunk+sizeof(float);
  135.  
  136.     WriteChunk(MAPP_U_OFFSET, SizeofChunk+sizeof(float));
  137.     WriteFloat(m->u_offset);
  138.     size+=SizeofChunk+sizeof(float);
  139.  
  140.     WriteChunk(MAPP_V_OFFSET, SizeofChunk+sizeof(float));
  141.     WriteFloat(-m->v_offset);
  142.     size+=SizeofChunk+sizeof(float);
  143.  
  144.     WriteChunk(MAPP_ROTATION, SizeofChunk+sizeof(float));
  145.     WriteFloat(-m->rotation);
  146.     size+=SizeofChunk+sizeof(float);
  147.  
  148.     WritePatch(bpatch, size);
  149.  
  150.     return size;
  151. }
  152.  
  153. long export3ds::WriteMatEntries(material *matlib, int nmatlib)
  154. {
  155.     const long SizeofColor=SizeofChunk+3;
  156.  
  157.     long size=0, itemSize, bpatch;
  158.  
  159.     for(int i=0;i<nmatlib;i++)
  160.     {
  161.         itemSize=0;
  162.         
  163.         bpatch=WriteChunk(MAT_ENTRY, 0);
  164.         itemSize+=SizeofChunk;
  165.  
  166.         itemSize+=WriteChunkString(MAT_NAME, matlib[i].name);
  167.  
  168.         WriteChunk(MAT_AMBIENT, SizeofChunk+SizeofColor);
  169.         WriteColor(matlib[i].ambient);
  170.         itemSize+=SizeofChunk+SizeofColor;
  171.  
  172.         WriteChunk(MAT_DIFFUSE, SizeofChunk+SizeofColor);
  173.         WriteColor(matlib[i].diffuse);
  174.         itemSize+=SizeofChunk+SizeofColor;
  175.  
  176.         WriteChunk(MAT_SPECULAR, SizeofChunk+SizeofColor);
  177.         WriteColor(matlib[i].specular);
  178.         itemSize+=SizeofChunk+SizeofColor;
  179.  
  180.         WriteChunk(MAT_SHININESS, SizeofChunk*2+sizeof(short));
  181.         WriteChunk(INT_PERCENTAGE, SizeofChunk+sizeof(short));
  182.         WriteShort((short)(matlib[i].shininess*100.0));
  183.         itemSize+=SizeofChunk*2+sizeof(short);
  184.  
  185.         WriteChunk(MAT_SHININESS_STRENGTH, SizeofChunk*2+sizeof(short));
  186.         WriteChunk(INT_PERCENTAGE, SizeofChunk+sizeof(short));
  187.         WriteShort((short)(matlib[i].shininess_strength*100.0));
  188.         itemSize+=SizeofChunk*2+sizeof(short);
  189.  
  190.         WriteChunk(MAT_TRANSPARENCY, SizeofChunk*2+sizeof(short));
  191.         WriteChunk(INT_PERCENTAGE, SizeofChunk+sizeof(short));
  192.         WriteShort((short)(matlib[i].transparency*100.0));
  193.         itemSize+=SizeofChunk*2+sizeof(short);
  194.  
  195.         WriteChunk(MAT_TRANSPARENCY_FALLOFF, SizeofChunk*2+sizeof(short));
  196.         WriteChunk(INT_PERCENTAGE, SizeofChunk+sizeof(short));
  197.         WriteShort((short)(matlib[i].transparency_falloff*100.0));
  198.         itemSize+=SizeofChunk*2+sizeof(short);
  199.  
  200.         WriteChunk(MAT_REFLECT_BLUR, SizeofChunk*2+sizeof(short));
  201.         WriteChunk(INT_PERCENTAGE, SizeofChunk+sizeof(short));
  202.         WriteShort((short)(matlib[i].reflect_blur*100.0));
  203.         itemSize+=SizeofChunk*2+sizeof(short);
  204.  
  205.         WriteChunk(MAT_SELF_ILLUM, SizeofChunk*2+sizeof(short));
  206.         WriteChunk(INT_PERCENTAGE, SizeofChunk+sizeof(short));
  207.         WriteShort((short)(matlib[i].self_illum*100.0));
  208.         itemSize+=SizeofChunk*2+sizeof(short);
  209.  
  210.         WriteChunk(MAT_SHADING, SizeofChunk+sizeof(short));
  211.         WriteShort(matlib[i].material_type);
  212.         itemSize+=SizeofChunk+sizeof(short);
  213.  
  214.         itemSize+=WriteChunkMapping(MAT_MAP_TEXTURE1, &matlib[i].map_texture1);
  215.         itemSize+=WriteChunkMapping(MAT_MAP_SPECULAR, &matlib[i].map_specular);
  216.         itemSize+=WriteChunkMapping(MAT_MAP_OPACITY, &matlib[i].map_opacity);
  217.         itemSize+=WriteChunkMapping(MAT_MAP_REFLECTION, &matlib[i].map_reflection);
  218.         itemSize+=WriteChunkMapping(MAT_MAP_BUMP, &matlib[i].map_bump);
  219.         itemSize+=WriteChunkMapping(MAT_MAP_TEXTURE2, &matlib[i].map_texture2);
  220.         itemSize+=WriteChunkMapping(MAT_MAP_SHININESS, &matlib[i].map_shininess);
  221.         itemSize+=WriteChunkMapping(MAT_MAP_SELFILLUM, &matlib[i].map_selfillum);
  222.  
  223.         WritePatch(bpatch, itemSize);
  224.  
  225.         size+=itemSize;
  226.     }
  227.  
  228.     return size;
  229. }
  230.  
  231. long export3ds::WriteColor(float c[3])
  232. {
  233.     WriteChunk(COLOR_24, SizeofChunk+sizeof(unsigned char)*3);
  234.     WriteUByte((unsigned char) (c[0]*255.0+0.5));
  235.     WriteUByte((unsigned char) (c[1]*255.0+0.5));
  236.     WriteUByte((unsigned char) (c[2]*255.0+0.5));
  237.     
  238.     return SizeofChunk+sizeof(unsigned char)*3;
  239. }
  240.  
  241. void export3ds::WriteNamedObject(
  242.     char *name, float *vert, float *textcoord,
  243.     unsigned short nv, unsigned short *faces, 
  244.     unsigned short nf, unsigned short *mat, 
  245.     int lmat, material *matlib,float *local_axis)
  246. {
  247.     long bpatch, itemSize;
  248.     char nameI[64];
  249.  
  250.     if(m_fp==NULL)
  251.         return;
  252.  
  253.     strcpy(nameI, name);
  254.  
  255.     bpatch=WriteChunk(NAMED_OBJECT, 0);
  256.     WriteString(nameI);
  257.     itemSize=SizeofChunk+strlen(nameI)+1;
  258.  
  259.     itemSize+=WriteTriObject(vert, textcoord, nv, faces, nf, mat, lmat, matlib, local_axis);
  260.  
  261.     WritePatch(bpatch, itemSize);
  262.  
  263.     MDATA_size+=itemSize;
  264. }
  265.  
  266. long export3ds::WriteTextCoord(float *textcoord, unsigned short nv)
  267. {
  268.     long size=0;
  269.  
  270.     if(textcoord)
  271.     {
  272.         size=SizeofChunk+sizeof(unsigned short)+
  273.             (nv*sizeof(float)*2);
  274.  
  275.         WriteChunk(TEXT_COORD, size);
  276.         WriteUShort(nv);
  277.         for(unsigned short i=0;i<nv;i++)
  278.         {
  279.             WriteFloat(textcoord[2*i]);
  280.             WriteFloat(-textcoord[2*i+1]);
  281.         }
  282.     }
  283.  
  284.     return size;
  285. }
  286.  
  287. long export3ds::WriteTriObject(float *vert, float *textcoord, unsigned short nv, unsigned short *faces, unsigned short nf, unsigned short *mat, int lmat, material *matlib,float *local_axis)
  288. {
  289.     long size=0;
  290.     long tripatch;
  291.  
  292.     tripatch=WriteChunk(N_TRI_OBJECT, 0);
  293.     size+=SizeofChunk;
  294.  
  295.     size+=WritePointArray(vert, nv);
  296.     size+=WriteTextCoord(textcoord, nv);
  297.     size+=WriteFaceArray(faces, nf, mat, lmat, matlib);
  298.  
  299.     long itemSize=SizeofChunk+sizeof(float)*12;
  300.     WriteChunk(LOCAL_AXIS, itemSize);
  301.     for(int i=0;i<12;i++)
  302.         if (local_axis)
  303.             WriteFloat(local_axis[i]);
  304.         else if (i==0 || i==4 || i==8)
  305.                 WriteFloat(1.0f);
  306.             else WriteFloat(0.0f);
  307.     size+=itemSize;
  308.     
  309.     WritePatch(tripatch, size);
  310.  
  311.     return size;
  312. }
  313.  
  314. long export3ds::WritePointArray(float *vert, unsigned short nv)
  315. {
  316.     long size=SizeofChunk+sizeof(unsigned short)+
  317.         sizeof(float)*3*nv;
  318.  
  319.     WriteChunk(POINT_ARRAY, size);
  320.     WriteUShort(nv);
  321.     for(unsigned short i=0; i<nv;i++)
  322.     {
  323.         WriteFloat(vert[3*i]);
  324.         WriteFloat(vert[3*i+1]);
  325.         WriteFloat(vert[3*i+2]);
  326.     }
  327.     
  328.     return size;
  329. }
  330.  
  331. long export3ds::WriteMaterial(unsigned short *mat, int lmat, material *matlib)
  332. {
  333.     long size=0, itemSize;
  334.     int i=0, j;
  335.  
  336.     while(i<lmat)
  337.     {
  338.         itemSize=SizeofChunk+
  339.             strlen(matlib[mat[i]].name)+1+
  340.             sizeof(unsigned short)+
  341.             (sizeof(short)*mat[i+1]);
  342.  
  343.         size+=itemSize;
  344.  
  345.         WriteChunk(MSH_MAT_GROUP, itemSize);
  346.         WriteString(matlib[mat[i]].name);
  347.  
  348.         WriteUShort((unsigned short)mat[i+1]);
  349.  
  350.         for(j=0;j<mat[i+1];j++)
  351.             WriteUShort(mat[i+1+j+1]);
  352.  
  353.         i+=2+mat[i+1];
  354.     }
  355.  
  356.     return size;
  357. }
  358.  
  359. long export3ds::WriteFaceArray(unsigned short *faces, unsigned short nf, unsigned short *mat, int lmat, material *matlib)
  360. {
  361.     long size=0, bpatch;
  362.     unsigned short i;
  363.  
  364.     bpatch=WriteChunk(FACE_ARRAY, 0);
  365.     WriteUShort((unsigned short)nf);
  366.     
  367.     size=SizeofChunk+sizeof(unsigned short)+
  368.         (4*sizeof(unsigned short)*nf);
  369.  
  370.     for(i=0;i<nf;i++)
  371.         {
  372.         WriteUShort(faces[i*3]);
  373.         WriteUShort(faces[i*3+1]);
  374.         WriteUShort(faces[i*3+2]);
  375.         WriteUShort((unsigned short)7);
  376.         }
  377.  
  378.     long itemSize=SizeofChunk+sizeof(unsigned long)*nf;
  379.     WriteChunk(SMOOTH_GROUP, itemSize);
  380.     for(i=0;i<nf;i++)
  381.         WriteULong(1);
  382.     size+=itemSize;
  383.  
  384.     size+=WriteMaterial(mat, lmat, matlib);
  385.  
  386.     WritePatch(bpatch, size);
  387.     
  388.     return size;
  389. }
  390.  
  391. void export3ds::WriteUShort(unsigned short d)
  392. {
  393.     fwrite(&d, sizeof(unsigned short), 1, m_fp);
  394. }
  395.  
  396. void export3ds::WriteULong(unsigned long d)
  397. {
  398.     fwrite(&d, sizeof(unsigned long), 1, m_fp);
  399. }
  400.  
  401. void export3ds::WriteLong(long d)
  402. {
  403.     fwrite(&d, sizeof(long), 1, m_fp);
  404. }
  405.  
  406. void export3ds::WriteByte(char d)
  407. {
  408.     fwrite(&d, sizeof(char), 1, m_fp);
  409. }
  410. void export3ds::WriteFloat(float d)
  411. {
  412.     fwrite(&d, sizeof(float), 1, m_fp);
  413. }
  414. void export3ds::WriteShort(short d)
  415. {
  416.     fwrite(&d, sizeof(short), 1, m_fp);
  417. }
  418. void export3ds::WriteUByte(unsigned char d)
  419. {
  420.     fwrite(&d, sizeof(unsigned char), 1, m_fp);
  421. }
  422.